package com.atguigu.jxc.service.impl;

import com.atguigu.jxc.dao.GoodsDao;
import com.atguigu.jxc.dao.GoodsTypeDao;
import com.atguigu.jxc.domain.ErrorCode;
import com.atguigu.jxc.domain.ServiceVO;
import com.atguigu.jxc.domain.SuccessCode;
import com.atguigu.jxc.entity.Goods;
import com.atguigu.jxc.entity.GoodsType;
import com.atguigu.jxc.service.GoodsService;
import com.atguigu.jxc.service.GoodsTypeService;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;


@Service
public class GoodsTypeServiceImpl implements GoodsTypeService {



    @Autowired
    private GoodsTypeDao goodsTypeDao;

    @Autowired
    private GoodsDao goodsDao;

    @Override
    public String loadGoodsType() {
        // 获取所有商品类型
        List<GoodsType> allGoodsType = goodsTypeDao.getAllGoodsType();
        // 遍历所有商品类型:判断是否是根节（-1）点如果是根节点，则用根节点的id作为二级类型的父节点PId，
        // 查询到所有的二级类型,给需要返回的参数赋值，并进行二级类型的遍历、查询、赋值
        JsonArray result = buildGoodsTypeTree(allGoodsType);
        return result.toString();
    }

    /**
     * 构建商品类型树
     * @param allGoodsType 所有商品类型
     * @return JsonArray 商品类型数组
     */
    public JsonArray buildGoodsTypeTree(List<GoodsType> allGoodsType) {
        // 初始化根节点数组
        JsonArray rootArray = new JsonArray();
        // 遍历所有商品类型，找到根节点（PId=-1）
        for (GoodsType rootType : allGoodsType) {
            if (rootType.getPId() == -1) {
                JsonObject rootNode = buildNode(rootType);
                rootArray.add(rootNode);
            }
        }
        return rootArray;
    }
    /**
     * 构建子节点
     * @param goodsType 商品类型
     * @return JsonObject 节点对象
     */
    private JsonObject buildNode(GoodsType goodsType) {
        //初始化创建节点对象
        JsonObject node = new JsonObject();
        // 添加基础属性
        node.addProperty("id", goodsType.getGoodsTypeId());
        node.addProperty("text", goodsType.getGoodsTypeName());
        node.addProperty("iconCls", "goods-type");

        // 构建attributes对象
        JsonObject attributes = new JsonObject();
        attributes.addProperty("state", goodsType.getGoodsTypeState());
        node.add("attributes", attributes);

        // 递归获取子节点
        List<GoodsType> childrenTypes = goodsTypeDao.getGoodsTypeByParentId(goodsType.getGoodsTypeId());
        // 初始化创建子节点Array对象
        JsonArray childrenArray = new JsonArray();
        //  判断从数据库获取到的子节点是否为空
        if (!childrenTypes.isEmpty()) {
            for (GoodsType child : childrenTypes) {
                JsonObject childNode = buildNode(child);  // 递归调用
                childrenArray.add(childNode);
            }
            node.add("children", childrenArray);
            // 根据是否有子节点设置state（有子节点为closed，否则为open）
            node.addProperty("state", "closed");
        } else {
            //不为空则说明是叶子节点
            node.addProperty("state", "open");
        }
        return node;
    }

    /**
     * 保存商品类型
     * 此方法根据商品类型名称和父节点ID保存商品类型信息
     *
     * @param goodsTypeName String 商品类型名称
     * @param pId           Integer 父节点ID
     * @return ServiceVO<Object>
     */
    @Override
    public ServiceVO<Object> saveGoodsType(String goodsTypeName, Integer pId) {
        GoodsType goodsType = new GoodsType();
        goodsType.setGoodsTypeName(goodsTypeName);
        goodsType.setGoodsTypeState(0);
        goodsType.setPId(pId);
        int index = goodsTypeDao.saveGoodsType(goodsType);
        if (index > 0) {
            return new ServiceVO<>(SuccessCode.SUCCESS_CODE, SuccessCode.SUCCESS_MESS, goodsType);
        }
        return new ServiceVO<>(ErrorCode.REQ_ERROR_CODE, ErrorCode.REQ_ERROR_MESS, goodsType);

    }

    /**
     * 删除商品类型
     * 此方法根据商品类型ID删除商品类型信息
     *
     * @param goodsTypeId Integer 商品类型ID
     * @return ServiceVO<Object>
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ServiceVO<Object> deleteGoodsTypeById(Integer goodsTypeId) {
        //判断是否有子节点
        List<GoodsType> childTypes = goodsTypeDao.getGoodsTypeByParentId(goodsTypeId);
        if (!childTypes.isEmpty()) {
            for (GoodsType child : childTypes) {
                deleteGoodsTypeById(child.getGoodsTypeId());
            }
        }
        //判断是否有商品
        List<Goods> goods = goodsDao.listInventory(null, null, null, goodsTypeId);
        //如果不为空则不能删除直接返回false
        if (!goods.isEmpty()) {
            return new ServiceVO<>(ErrorCode.GOODS_TYPE_ERROR_CODE, ErrorCode.GOODS_TYPE_ERROR_MESS, goodsTypeId);
        }
        //删除商品类型
        int result = goodsTypeDao.deleteGoodsTypeById(goodsTypeId);
        if (result > 0){
            return new ServiceVO<>(SuccessCode.SUCCESS_CODE, SuccessCode.SUCCESS_MESS, goodsTypeId);
        }
        return new ServiceVO<>(ErrorCode.DELETE_ERROR_CODE, ErrorCode.DELETE_ERROR_MESS, goodsTypeId);
    }
}
